#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""交易执行器模块
负责执行交易指令和管理订单"""

import time
from datetime import datetime
from utils import Logger
from tencent_api_connector import TencentAPIConnector
from risk_manager import RiskManager

class TradeExecutor:
    """交易执行器
    负责执行交易下单、查询订单状态和管理交易历史"""
    
    def __init__(self, api_connector=None, risk_manager=None):
        """初始化交易执行器
        
        Args:
            api_connector: API连接器实例
            risk_manager: 风险管理器实例
        """
        # 如果没有提供API连接器，则创建一个新的
        self.api_connector = api_connector if api_connector else TencentAPIConnector()
        
        # 如果没有提供风险管理器，则创建一个新的
        self.risk_manager = risk_manager if risk_manager else RiskManager()
        
        # 交易记录
        self.trade_history = []
        self.active_orders = {}
        
        # 交易配置
        self.order_timeout = 30  # 订单超时时间(秒)
        self.risk_control_enabled = True  # 启用风险控制
        
        Logger.log_info("交易执行器初始化完成")
    
    def place_order(self, stock_code, order_type, quantity, price):
        """下单交易，先进行风险评估，再调用API
        
        Args:
            stock_code: 股票代码
            order_type: 订单类型（'buy'或'sell'）
            quantity: 交易数量
            price: 交易价格
            
        Returns:
            dict: 订单执行结果
        """
        try:
            # 简单的交易参数验证
            if not isinstance(stock_code, str) or not stock_code:
                return {"success": False, "message": "股票代码无效"}
                
            if order_type.lower() not in ['buy', 'sell']:
                return {"success": False, "message": "订单类型无效，必须是'buy'或'sell'"}
                
            if not isinstance(quantity, (int, float)) or quantity <= 0:
                return {"success": False, "message": "交易数量必须大于0"}
                
            if not isinstance(price, (int, float)) or price <= 0:
                return {"success": False, "message": "交易价格必须大于0"}
            
            # 构建交易数据，用于风险评估
            trade_data = {
                "stock_code": stock_code,
                "order_type": order_type,
                "quantity": quantity,
                "price": price
            }
            
            # 进行风险评估
            if self.risk_control_enabled:
                risk_evaluation = self.risk_manager.evaluate_trade_risk(trade_data)
                Logger.log_info(f"风险评估结果: {risk_evaluation}")
                
                # 如果风险评估不通过，拒绝执行交易
                if not risk_evaluation.get("pass", False):
                    Logger.log_warning(f"交易被风险控制机制拒绝: {risk_evaluation.get('message', '未知原因')}")
                    return {
                        "success": False,
                        "message": f"交易被风险控制机制拒绝: {risk_evaluation.get('message', '未知原因')}",
                        "risk_evaluation": risk_evaluation
                    }
            
            # 风险评估通过，调用API连接器的place_order方法进行下单
            Logger.log_info(f"调用API下单: {stock_code} {order_type} {quantity}股 @ {price}")
            response = self.api_connector.place_order(stock_code, order_type, quantity, price)
            
            if not response or not response.get("success", False):
                message = response.get("message", "未知错误") if response else "API调用失败"
                Logger.log_error(f"下单失败: {message}")
                return {"success": False, "message": message}
            
            # 获取订单信息
            order_info = response.get("order_info", {})
            order_id = response.get("order_id")
            
            # 等待并查询订单状态（模拟实际交易流程）
            self._wait_for_order_execution(order_id)
            
            # 查询最新订单状态
            query_response = self.api_connector.query_order(order_id)
            if query_response and query_response.get("success", False):
                latest_order_info = query_response.get("order_info", {})
                order_info.update(latest_order_info)
            
            # 保存到交易历史
            self.trade_history.append(order_info)
            self.active_orders[order_id] = order_info
            
            Logger.log_info(f"订单已处理完成: {order_id}")
            # 返回符合测试期望的结果格式
            return {
                "success": True,
                "order_id": order_id,
                "message": response.get("message", "交易执行成功"),
                "order_info": order_info
            }
        except Exception as e:
            error_message = f"下单失败: {str(e)}"
            Logger.log_error(error_message)
            return {
                "success": False,
                "message": error_message
            }
    
    def cancel_order(self, order_id):
        """取消订单
        
        Args:
            order_id: 订单ID
            
        Returns:
            bool: 取消是否成功
        """
        try:
            if order_id not in self.active_orders:
                Logger.log_warning(f"订单不存在: {order_id}")
                return False
            
            order = self.active_orders[order_id]
            
            # 检查订单状态，只有待成交的订单才能取消
            if order["status"] != "pending":
                Logger.log_warning(f"订单 {order_id} 状态为 {order['status']}，无法取消")
                return False
            
            # 模拟取消订单处理
            time.sleep(0.3)
            
            # 更新订单状态为已取消
            order["status"] = "cancelled"
            order["update_time"] = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            
            Logger.log_info(f"订单已取消: {order_id}")
            return True
        except Exception as e:
            Logger.log_error(f"取消订单失败: {str(e)}")
            return False
    
    def get_order_status(self, order_id):
        """查询订单状态
        
        Args:
            order_id: 订单ID
            
        Returns:
            dict: 订单信息或None
        """
        if order_id in self.active_orders:
            return self.active_orders[order_id]
        
        # 在历史订单中查找
        for order in self.trade_history:
            if order["order_id"] == order_id:
                return order
        
        Logger.log_warning(f"未找到订单: {order_id}")
        return None
    
    def _wait_for_order_execution(self, order_id):
        """等待订单执行完成（模拟）
        
        Args:
            order_id: 订单ID
        """
        Logger.log_info(f"等待订单执行: {order_id}")
        # 在实际环境中，这里可能需要循环查询订单状态，直到订单执行完成
        # 这里简单模拟等待过程
        time.sleep(0.8)  # 模拟订单执行时间
        
    def cancel_order(self, order_id):
        """取消订单，直接调用真实API
        
        Args:
            order_id: 订单ID
            
        Returns:
            bool: 取消是否成功
        """
        try:
            if order_id not in self.active_orders:
                Logger.log_warning(f"订单不存在: {order_id}")
                return False
            
            # 检查订单状态，只有待成交的订单才能取消
            order = self.active_orders[order_id]
            if order.get("status") != "pending" and order.get("status") != "partially_filled":
                Logger.log_warning(f"订单 {order_id} 状态为 {order.get('status', 'unknown')}，无法取消")
                return False
            
            Logger.log_info(f"调用API取消订单: {order_id}")
            response = self.api_connector.cancel_order(order_id)
            
            if not response or not response.get("success", False):
                message = response.get("message", "未知错误") if response else "API调用失败"
                Logger.log_error(f"取消订单失败: {message}")
                return False
            
            # 更新订单状态
            order["status"] = "cancelled"
            order["update_time"] = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            
            Logger.log_info(f"订单已取消: {order_id}")
            return True
        except Exception as e:
            Logger.log_error(f"取消订单失败: {str(e)}")
            return False
    
    def get_order_status(self, order_id):
        """查询订单状态，优先从API获取最新状态
        
        Args:
            order_id: 订单ID
            
        Returns:
            dict: 订单信息或None
        """
        try:
            Logger.log_info(f"查询订单状态: {order_id}")
            # 直接从API查询最新状态
            response = self.api_connector.query_order(order_id)
            
            if response and response.get("success", False):
                order_info = response.get("order_info", {})
                
                # 更新本地存储的订单信息
                if order_id in self.active_orders:
                    self.active_orders[order_id].update(order_info)
                
                # 在历史订单中查找并更新
                for order in self.trade_history:
                    if order.get("order_id") == order_id:
                        order.update(order_info)
                        break
                
                return order_info
            
            # 如果API查询失败，尝试返回本地存储的信息
            if order_id in self.active_orders:
                return self.active_orders[order_id]
            
            # 在历史订单中查找
            for order in self.trade_history:
                if order.get("order_id") == order_id:
                    return order
            
            Logger.log_warning(f"未找到订单: {order_id}")
            return None
        except Exception as e:
            Logger.log_error(f"查询订单状态失败: {str(e)}")
            # 如果发生异常，尝试返回本地存储的信息
            if order_id in self.active_orders:
                return self.active_orders[order_id]
            
            for order in self.trade_history:
                if order.get("order_id") == order_id:
                    return order
            
            return None
    
    def get_trade_history(self, start_date=None, end_date=None):
        """获取交易历史
        
        Args:
            start_date: 开始日期
            end_date: 结束日期
            
        Returns:
            list: 交易历史列表
        """
        # 简单实现，返回所有交易历史
        # 在实际应用中，应该根据日期过滤
        return self.trade_history
    
    def get_active_orders(self):
        """获取所有活跃订单
        
        Returns:
            list: 活跃订单列表
        """
        return list(self.active_orders.values())